package com.ccnode.codegenerator.taikaoback.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ccnode.codegenerator.taikaoback.entity.User;
import com.ccnode.codegenerator.taikaoback.mapper.UserMapper;
import com.ccnode.codegenerator.taikaoback.service.UserService;
import com.ccnode.codegenerator.taikaoback.util.PasswordUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;

import java.util.UUID;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户服务实现
 */
@Service
public class UserServiceImpl implements UserService, UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 查询用户
        User user = getByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("用户不存在");
        }

        // 创建LoginUser对象
        com.ccnode.codegenerator.taikaoback.entity.LoginUser loginUser = 
            new com.ccnode.codegenerator.taikaoback.entity.LoginUser();
        loginUser.setUsername(user.getUname());
        loginUser.setPassword(user.getUpwd());
        return loginUser;
    }
    
    @Override
    public boolean updatePassword(String id, String newPassword) {
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(User::getUid, id); // User实体类中使用的是uid而不是id
        updateWrapper.set(User::getUpwd, PasswordUtil.encodePassword(newPassword));
        // User实体类中没有updateTime字段，移除相关代码
        return userMapper.update(null, updateWrapper) > 0;
    }

    @Override
    public User getByUsername(String username) {
        // 从数据库查询用户
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUname, username);
        return userMapper.selectOne(queryWrapper);
    }

    @Override
    public User getByPhone(String phone) {
        // 从数据库查询用户
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUphone, phone);
        return userMapper.selectOne(queryWrapper);
    }

    @Override
    public User login(String username, String password) {
        // 查询用户
        User user = getByUsername(username);

        // 验证密码（仅使用BCrypt验证，确保安全性）
        if (user != null) { // 移除了对status字段的检查，因为User实体类中没有这个字段
            // 检查密码是否为明文格式
            if (PasswordUtil.isPlainTextPassword(user.getUpwd())) {
                // 如果是明文密码，先验证是否正确，然后自动升级为加密密码
                if (password.equals(user.getUpwd())) {
                    // 自动升级密码为加密格式
                    upgradePasswordToEncrypted(username, password);
                    return user;
                }
            } else {
                // 使用工具类验证加密密码
                if (PasswordUtil.matches(password, user.getUpwd())) {
                    return user;
                }
            }
        }

        return null;
    }

    @Override
    public Map<String, Object> getUserStats(String username) {
        // User实体类中没有这些字段，暂时返回空map
        return new HashMap<>();
    }

    @Override
    public List<Map<String, Object>> getLoginRecords(String username) {
        // User实体类中没有这些字段，暂时返回空列表
        return new ArrayList<>();
    }

    @Override
    public boolean changePassword(String username, String oldPassword, String newPassword) {
        User user = getByUsername(username);
        if (user == null) {
            return false;
        }

        // 验证旧密码（支持明文和加密密码）
        boolean oldPasswordValid = false;
        if (PasswordUtil.isPlainTextPassword(user.getUpwd())) {
            // 明文密码验证
            oldPasswordValid = oldPassword.equals(user.getUpwd());
        } else {
            // 加密密码验证
            oldPasswordValid = PasswordUtil.matches(oldPassword, user.getUpwd());
        }

        if (!oldPasswordValid) {
            return false;
        }

        // 更新密码（始终加密新密码）
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(User::getUname, username);
        updateWrapper.set(User::getUpwd, PasswordUtil.encodePassword(newPassword));
        // User实体类中没有updateTime字段，移除相关代码

        return userMapper.update(null, updateWrapper) > 0;
    }

    /**
     * 自动升级明文密码为加密密码
     */
    private void upgradePasswordToEncrypted(String username, String plainPassword) {
        try {
            LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(User::getUname, username);
            updateWrapper.set(User::getUpwd, PasswordUtil.encodePassword(plainPassword));
            // User实体类中没有updateTime字段，移除相关代码

            userMapper.update(null, updateWrapper);
        } catch (Exception e) {
            // 记录日志但不影响登录流程
            System.err.println("密码升级失败: " + e.getMessage());
        }
    }

    @Override
    public boolean updateProfile(String username, User user) {
        return updateProfile(username, user, null);
    }

    @Override
    public boolean updateProfile(String username, User user, MultipartFile avatarFile) {
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(User::getUname, username);


        // 处理头像上传
        if (avatarFile != null && !avatarFile.isEmpty()) {
            try {
                // 生成文件名
                String fileName = UUID.randomUUID().toString() + ".jpg";
                // 简化的文件存储路径
                String filePath = "uploads/" + fileName;
                
                // 在实际项目中，你需要将文件保存到服务器或云存储中
                // 这里只是示例，实际项目中需要实现文件存储逻辑
                // avatarFile.transferTo(new File(filePath));
                
                // User实体类中没有avatar字段，移除相关代码
                // updateWrapper.set(User::getAvatar, "/uploads/" + fileName);
            } catch (Exception e) {
                throw new RuntimeException("头像上传失败", e);
            }
        }

        // User实体类中没有updateTime字段，移除相关代码

        return userMapper.update(null, updateWrapper) > 0;
    }

    @Override
    public void updateLastLoginInfo(String username, String ip) {
        LambdaUpdateWrapper<User> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(User::getUname, username);
        // User实体类中没有这些字段，移除相关代码
        // updateWrapper.set(User::getLastLoginTime, LocalDateTime.now());
        // updateWrapper.set(User::getLastLoginIp, ip);
        // updateWrapper.setSql("login_count = IFNULL(login_count, 0) + 1");

        userMapper.update(null, updateWrapper);
    }

    @Override
    public User getById(String id) {
        return userMapper.selectById(id);
    }

    @Override
    public IPage<User> getUserList(Integer page, Integer size, String username, String role, Integer status) {
        Page<User> pageParam = new Page<>(page, size);
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();

        if (StringUtils.hasText(username)) {
            queryWrapper.like(User::getUname, username);
            // User实体类中没有realName字段，移除相关代码
            // .or()
            // .like(User::getRealName, username);
        }
        // User实体类中没有role和status字段，移除相关代码
        // if (StringUtils.hasText(role)) {
        //     queryWrapper.eq(User::getRole, role);
        // }
        // if (status != null) {
        //     queryWrapper.eq(User::getStatus, status);
        // }

        queryWrapper.orderByDesc(User::getUid); // User实体类中没有createTime字段，改为使用uid排序

        return userMapper.selectPage(pageParam, queryWrapper);
    }

    @Override
    public boolean addUser(User user) {
        // 检查用户名是否已存在
        if (getByUsername(user.getUname()) != null) {
            return false;
        }

        // 加密密码
        if (StringUtils.hasText(user.getUpwd())) {
            user.setUpwd(PasswordUtil.encodePassword(user.getUpwd()));
        }

        return userMapper.insert(user) > 0;
    }

    @Override
    public boolean updateUser(User user) {
        if (user.getUid() == null) { // User实体类中使用的是uid而不是id
            return false;
        }
        // User实体类中没有updateTime字段，移除相关代码
        // user.setUpdateTime(LocalDateTime.now());

        // 如果有新密码，需要加密
        if (StringUtils.hasText(user.getUpwd())) {
            user.setUpwd(PasswordUtil.encodePassword(user.getUpwd()));
        }

        return userMapper.updateById(user) > 0;
    }

    @Override
    public boolean deleteUser(Long id) {
        return userMapper.deleteById(id) > 0;
    }

    @Override
    public boolean updateStatus(Long id, Integer status) {
        // User实体类中没有status字段，直接返回false
        return false;
    }
}

